package com.cykj.order.service.impl;

import com.cykj.order.domain.CtCart;
import com.cykj.order.domain.CtItem;
import com.cykj.order.domain.vo.CartInfoVo;
import com.cykj.order.domain.vo.CartItemVo;
import com.cykj.order.domain.enums.CartOperationType;

import com.cykj.order.domain.dto.AddCartItemDto;
import com.cykj.order.domain.dto.CartItemOperationDto;
import com.cykj.order.mapper.CartMapper;
import com.cykj.order.service.ICartService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.sql.Timestamp;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 购物车Service业务层处理
 * 
 * @author cykj
 * @date 2025-01-20
 */
@Service
public class  CartServiceImpl implements ICartService {
    
    @Autowired
    private CartMapper cartMapper;
    
    /**
     * 初始化购物车
     * 根据用户ID和店铺ID查询购物车，如果不存在则创建新的购物车
     * 
     * @param customerId 用户ID
     * @param businessId 店铺ID
     * @return 购物车信息（包含购物车ID和商品明细）
     */
    @Override
    @Transactional
    public CartInfoVo initializeCart(Integer customerId, Integer businessId) {
        // 参数验证
        if (customerId == null || businessId == null) {
            throw new IllegalArgumentException("用户ID和店铺ID不能为空");
        }
        // 先查询是否已存在购物车
        CtCart existingCart = cartMapper.selectCartByCustomerAndBusiness(customerId, businessId);
        
        CartInfoVo cartInfoVo = new CartInfoVo();
        
        if (existingCart != null) {
            // 购物车已存在，返回购物车信息和商品明细
            cartInfoVo.setCartId(existingCart.getId());
            cartInfoVo.setCustomerId(existingCart.getCustomerId());
            cartInfoVo.setBusinessId(existingCart.getBusinessId());
            cartInfoVo.setCreateTime(existingCart.getCreateTime());
            
            // 查询购物车商品明细
            List<CartItemVo> cartItems = cartMapper.selectCartItemsByCartId(existingCart.getId());
            cartInfoVo.setItems(cartItems);
            
            // 计算购物车总价
            calculateAndSetTotalAmount(cartInfoVo);
            
            System.out.println("找到已存在的购物车，ID: " + existingCart.getId() + "，商品明细数量: " + 
                             (cartItems != null ? cartItems.size() : 0));
        } else {
            // 购物车不存在，创建新的购物车
            CtCart newCart = new CtCart();
            newCart.setCustomerId(customerId);
            newCart.setBusinessId(businessId);
            newCart.setCreateTime(new Timestamp(System.currentTimeMillis()));
            
            int result = cartMapper.insertCart(newCart);
            
            if (result > 0) {
                // 创建成功，返回新购物车信息
                cartInfoVo.setCartId(newCart.getId());
                cartInfoVo.setCustomerId(newCart.getCustomerId());
                cartInfoVo.setBusinessId(newCart.getBusinessId());
                cartInfoVo.setCreateTime(newCart.getCreateTime());
                cartInfoVo.setItems(null); // 新购物车没有商品明细
                cartInfoVo.setTotalAmount(0.0); // 新购物车总价为0
                
                System.out.println("创建新购物车成功，ID: " + newCart.getId());
            } else {
                System.err.println("创建购物车失败");
                throw new RuntimeException("创建购物车失败");
            }
        }
        
        return cartInfoVo;
    }
    
    /**
     * 添加商品到购物车
     * 注意：此方法用于将新商品添加到购物车，数量固定为1
     * 
     * @param addCartItemDto 添加购物车商品参数
     * @return 购物车信息（包含购物车ID和商品明细）
     * 
     * 业务场景：用户浏览商品列表，点击"加入购物车"按钮
     * 注意：只有未加入购物车的商品才显示此按钮
     */
    @Override   
    @Transactional
    public CartInfoVo addCartItem(AddCartItemDto addCartItemDto) {
        // 从数据库查询商品价格
        BigDecimal productPrice = cartMapper.selectProductPriceByProductId(addCartItemDto.getProductId());
        if (productPrice == null) {
            throw new RuntimeException("商品不存在或已下架");
        }
        
        // 直接新增商品到购物车（数量固定为1）
        CtItem newItem = new CtItem();
        newItem.setCartId(addCartItemDto.getCartId());
        newItem.setProductId(addCartItemDto.getProductId());
        newItem.setNumber(1); // 固定数量为1
        newItem.setProductPrice(productPrice);
        newItem.setCreateTime(new Timestamp(System.currentTimeMillis()));
        
        int insertResult = cartMapper.insertCartItem(newItem);
        if (insertResult <= 0) {
            throw new RuntimeException("添加购物车商品失败");
        }
        
        System.out.println("添加购物车商品成功，商品ID: " + addCartItemDto.getProductId() + "，数量: 1");
        
        // 返回更新后的购物车信息
        // 先查询购物车基本信息
        CtCart cart = cartMapper.selectCartByCartId(addCartItemDto.getCartId());
        if (cart == null) {
            throw new RuntimeException("购物车不存在");
        }
        
        CartInfoVo cartInfoVo = new CartInfoVo();
        cartInfoVo.setCartId(cart.getId());
        cartInfoVo.setCustomerId(cart.getCustomerId());
        cartInfoVo.setBusinessId(cart.getBusinessId());
        cartInfoVo.setCreateTime(cart.getCreateTime());

        // 查询购物车商品明细
        List<CartItemVo> cartItems = cartMapper.selectCartItemsByCartId(cart.getId());
        cartInfoVo.setItems(cartItems);
        
        // 计算购物车总价
        calculateAndSetTotalAmount(cartInfoVo);
        
        return cartInfoVo;
    }
    
    /**
     * 购物车商品操作（增加、减少、删除）
     * 注意：此方法仅用于操作购物车中已存在的商品
     * 
     * @param operationDto 操作参数
     * @return 购物车信息（包含购物车ID和商品明细）
     * 
     * 操作类型说明：
     * - ADD: 增加1个商品
     * - REDUCE: 减少1个商品
     * - DELETE: 删除商品
     * 
     * 业务场景：用户在购物车页面操作商品数量
     */
    @Override
    @Transactional
    public CartInfoVo operateCartItem(CartItemOperationDto operationDto) {
        Integer cartId = operationDto.getCartId();
        Integer productId = operationDto.getProductId();
        CartOperationType operationType = operationDto.getOperationType();
        
        // 直接查询购物车商品（因为前端保证商品存在）
        CtItem existingItem = cartMapper.selectCartItemByCartIdAndProductId(cartId, productId);
        
        if (existingItem == null) {
            throw new RuntimeException("购物车中不存在该商品");
        }
        
        // 根据操作类型处理数量
        int currentQuantity = existingItem.getNumber();
        int newQuantity;
        
        if (operationType.isAdd()) {
            // 增加操作：数量 +1
            newQuantity = currentQuantity + 1;
        } else if (operationType.isReduce()) {
            // 减少操作：数量 -1
            newQuantity = currentQuantity - 1;
        } else if (operationType.isDelete()) {
            // 删除操作：数量设为0
            newQuantity = 0;
        } else {
            throw new RuntimeException("不支持的操作类型");
        }
        
        // 处理数量变化
        if (newQuantity <= 0) {
            // 删除商品
            int deleteResult = cartMapper.deleteCartItem(cartId, productId);
            if (deleteResult <= 0) {
                throw new RuntimeException("删除购物车商品失败");
            }
        } else {
            // 更新数量
            existingItem.setNumber(newQuantity);
            int updateResult = cartMapper.updateCartItemNumber(existingItem);
            if (updateResult <= 0) {
                throw new RuntimeException("更新购物车商品数量失败");
            }
        }
        
        // 返回更新后的购物车信息
        // 先查询购物车基本信息
        CtCart cart = cartMapper.selectCartByCartId(cartId);
        if (cart == null) {
            throw new RuntimeException("购物车不存在");
        }
        
        CartInfoVo cartInfoVo = new CartInfoVo();
        cartInfoVo.setCartId(cart.getId());
        cartInfoVo.setCustomerId(cart.getCustomerId());
        cartInfoVo.setBusinessId(cart.getBusinessId());
        cartInfoVo.setCreateTime(cart.getCreateTime());

        // 查询购物车商品明细
        List<CartItemVo> cartItems = cartMapper.selectCartItemsByCartId(cart.getId());
        cartInfoVo.setItems(cartItems);
        
        // 计算购物车总价
        calculateAndSetTotalAmount(cartInfoVo);
        
        return cartInfoVo;
    }
    
    /**
     * 清空购物车
     * 删除购物车中的所有商品，但保留购物车本身
     * 
     * @param cartId 购物车ID
     * @return 购物车信息（包含购物车ID，商品明细为空）
     * 
     * 业务场景：用户点击"清空购物车"按钮
     */
    @Override
    @Transactional
    public CartInfoVo clearCart(Integer cartId) {
        // 删除购物车中的所有商品
        int deleteResult = cartMapper.clearCartItems(cartId);
        
        System.out.println("清空购物车成功，购物车ID: " + cartId + "，删除商品数量: " + deleteResult);
        
        // 返回清空后的购物车信息
        // 先查询购物车基本信息
        CtCart cart = cartMapper.selectCartByCartId(cartId);
        if (cart == null) {
            throw new RuntimeException("购物车不存在");
        }
        
        CartInfoVo cartInfoVo = new CartInfoVo();
        cartInfoVo.setCartId(cart.getId());
        cartInfoVo.setCustomerId(cart.getCustomerId());
        cartInfoVo.setBusinessId(cart.getBusinessId());
        cartInfoVo.setCreateTime(cart.getCreateTime());
        cartInfoVo.setItems(null); // 商品明细为空
        cartInfoVo.setTotalAmount(0.0); // 清空购物车后总价为0
        
        return cartInfoVo;
    }
    
    /**
     * 计算购物车总价并设置到CartInfoVo中
     * 
     * @param cartInfoVo 购物车信息VO
     */
    private void calculateAndSetTotalAmount(CartInfoVo cartInfoVo) {
        BigDecimal totalAmount = BigDecimal.ZERO;

        if (cartInfoVo.getItems() != null) {
            for (CartItemVo item : cartInfoVo.getItems()) {
                if (item.getProductPrice() != null && item.getNumber() != null && item.getNumber() > 0) {
                    totalAmount = totalAmount.add(
                            item.getProductPrice().multiply(new BigDecimal(item.getNumber()))
                    );
                }
            }
        }

        cartInfoVo.setTotalAmount(totalAmount.doubleValue());
    }


    @Override
    @Transactional(readOnly = true)
    public List<CartInfoVo> getAllCartsByUserId(Integer customerId) {
        if (customerId == null) {
            throw new IllegalArgumentException("用户ID不能为空");
        }

        // 查询用户所有购物车（按商家分组）
        List<CtCart> userCarts = cartMapper.selectAllCartsByCustomerId(customerId);
        if (userCarts == null || userCarts.isEmpty()) {
            return Collections.emptyList();
        }

        //  为每个购物车填充商品明细并计算总价
        List<CartInfoVo> result = new ArrayList<>();
        for (CtCart cart : userCarts) {
            CartInfoVo cartInfoVo = new CartInfoVo();
            cartInfoVo.setCartId(cart.getId());
            cartInfoVo.setCustomerId(cart.getCustomerId());
            cartInfoVo.setBusinessId(cart.getBusinessId());
            cartInfoVo.setCreateTime(cart.getCreateTime());

            // 查询购物车商品明细
            List<CartItemVo> cartItems = cartMapper.selectCartItemsByCartId(cart.getId());
            cartInfoVo.setItems(cartItems);

            // 计算总价
            calculateAndSetTotalAmount(cartInfoVo);

            result.add(cartInfoVo);
        }

        return result;
    }
}
